﻿using System;
using System.Collections.Generic;
using System.Data;
using System.Data.SqlClient;
using System.Reflection;
using Demo.CommonBase.DTO.Filters;
using Demo.CommonBase.DTO.Infos;
using Demo.CommonBase.Exceptions;
using Demo.CommonBase.Integration.DAO.Impl;
using Demo.CommonBase.Integration.DAO.IntegrationComponents.Mappings;
using Demo.CommonBase.Logging;
using Demo.Services.Contracts.DTO.Filters;
using Demo.Services.Contracts.DTO.Infos;
using Demo.Services.Integration.DAO.Contracts.Exceptions;
using Demo.Services.Integration.DAO.IntegrationComponents.Helpers;
using Demo.Services.Integration.DAO.IntegrationComponents.Mappings;

namespace Demo.Services.Integration.DAO.Impl
{
    public class ProyectDAO : DAOBase
    {
        public List<ProyectInfo> GetProyects(ProyectFilter filter)
        {
            List<ProyectInfo> proyects = null;
            IList<IDbDataParameter> paramsList;
            try
            {
                paramsList = ProyectDAOHelper.GetProyectByFilterParams(filter);
                DataSet ds = Retrieve("Proyect_R_ByName", paramsList);
                if (ValidateDataSet(ds))
                {
                    proyects = ProyectDAOMapping.GetProyectMapping(ds);
                }
            }
            catch (SqlException ex)
            {
                Logger.Error(ex);
                throw new ServiceDataException(ServiceDataException.DAO_METHOD_EXCEPTION, "ProyectDAO", ex);
            }
            catch (DataException ex)
            {
                Logger.Error(ex);
                throw new ServiceDataException(ServiceDataException.DAO_METHOD_EXCEPTION,
                                               "ProyectDAO", ex);
            }
            catch (Exception ex)
            {
                Logger.Error(ex);
                throw new UnhandledException(MethodBase.GetCurrentMethod(), ex);
            }
            return proyects;
        }

        /// <summary>
        /// Mètodo para guardar un proyecto
        /// </summary>
        /// <param name="nombre"></param>
        public int SaveProyect(ProyectInfo info)
        {
            int id = 0;
            try
            {
                IList<IDbDataParameter> parameters = ProyectDAOHelper.GetSaveParameters(info);
                id = Create("Proyect_C", parameters);
            }
            catch (SqlException ex)
            {
                Logger.Error(ex);
                throw new ServiceDataException(ServiceDataException.DAO_METHOD_EXCEPTION, "ProyectDAO", ex);
            }
            catch (DataException ex)
            {
                Logger.Error(ex);
                throw new ServiceDataException(ServiceDataException.DAO_METHOD_EXCEPTION,
                                               "ProyectDAO", ex);
            }
            catch (Exception ex)
            {
                Logger.Error(ex);
                throw new UnhandledException(MethodBase.GetCurrentMethod(), ex);
            }
            return id;
        }

        /// <summary>
        /// Mètodo para Actualizar un proyecto
        /// </summary>
        /// <param name="nombre"></param>
        public void UpdateProyect(ProyectInfo info)
        {
            try
            {
                IList<IDbDataParameter> parameters = ProyectDAOHelper.GetUpdateParameters(info);
                Update("Proyect_U", parameters);
            }
            catch (SqlException ex)
            {
                Logger.Error(ex);
                throw new ServiceDataException(ServiceDataException.DAO_METHOD_EXCEPTION, "ProyectDAO", ex);
            }
            catch (DataException ex)
            {
                Logger.Error(ex);
                throw new ServiceDataException(ServiceDataException.DAO_METHOD_EXCEPTION,
                                               "ProyectDAO", ex);
            }
            catch (Exception ex)
            {
                Logger.Error(ex);
                throw new UnhandledException(MethodBase.GetCurrentMethod(), ex);
            }
        }

        /// <summary>
        /// Mètodo para Borrar un proyecto
        /// </summary>
        /// <param name="nombre"></param>
        public void DeleteProyect(int id)
        {
            try
            {
                IList<IDbDataParameter> parameters = ProyectDAOHelper.GetIdParameter(id);
                Delete("Proyect_D", parameters);
            }
            catch (SqlException ex)
            {
                Logger.Error(ex);
                throw new ServiceDataException(ServiceDataException.DAO_METHOD_EXCEPTION, "ProyectDAO", ex);
            }
            catch (DataException ex)
            {
                Logger.Error(ex);
                throw new ServiceDataException(ServiceDataException.DAO_METHOD_EXCEPTION,
                                               "ProyectDAO", ex);
            }
            catch (Exception ex)
            {
                Logger.Error(ex);
                throw new UnhandledException(MethodBase.GetCurrentMethod(), ex);
            }
        }

        /// <summary>
        /// Mètodo que trae una lista de proyectos paginada
        /// </summary>
        /// <param name="nombre"></param>
        public ProjectResultInfo GetProyectList(PaginationInfo pagin, ProyectFilter filters)
        {
            DataSet ds;
            ProjectResultInfo result = null;
            IList<IDbDataParameter> paramsList;
            try
            {
                paramsList = ProyectDAOHelper.GetProyectByPage(pagin, filters);
                ds = Retrieve("Proyect_R", paramsList);
                if (ValidateDataSet(ds))
                {
                    result = ProyectDAOMapping.GetProjectList(ds);
                }
            }
            catch (SqlException ex)
            {
                Logger.Error(ex);
                throw new ServiceDataException(ServiceDataException.DAO_METHOD_EXCEPTION, "ProyectDAO", ex);
            }
            catch (DataException ex)
            {
                Logger.Error(ex);
                throw new ServiceDataException(ServiceDataException.DAO_METHOD_EXCEPTION,
                                               "ProyectDAO", ex);
            }
            catch (Exception ex)
            {
                Logger.Error(ex);
                throw new UnhandledException(MethodBase.GetCurrentMethod(), ex);
            }
            return result;
        }

        /// <summary>
        /// Mètodo para obtener un proyecto por Id
        /// </summary>
        /// <param name="nombre"></param>
        public ProyectInfo GetProyectById(int id)
        {
            DataSet ds;
            ProyectInfo result = null;
            try
            {
                IList<IDbDataParameter> parameters = ProyectDAOHelper.GetIdParameter(id);
                ds = Retrieve("Proyect_R_ById", parameters);
                if (ValidateDataSet(ds))
                {
                    result = ProyectDAOMapping.GetProjectById(ds);
                }
            }
            catch (SqlException ex)
            {
                Logger.Error(ex);
                throw new ServiceDataException(ServiceDataException.DAO_METHOD_EXCEPTION, "ProyectDAO", ex);
            }
            catch (DataException ex)
            {
                Logger.Error(ex);
                throw new ServiceDataException(ServiceDataException.DAO_METHOD_EXCEPTION,
                                               "ProyectDAO", ex);
            }
            catch (Exception ex)
            {
                Logger.Error(ex);
                throw new UnhandledException(MethodBase.GetCurrentMethod(), ex);
            }
            return result;
        }

        public CommonComboBoxPagingInfo GetProyect_ByName(ComboBoxFilter filter)
        {
            CommonComboBoxPagingInfo proyects = null;
            IList<IDbDataParameter> paramsList;
            try
            {
                Logger.Info();
                paramsList = ProyectDAOHelper.GetProyect_ByNameParams(filter);
                DataSet ds = Retrieve("Proyect_R_ByName", paramsList);
                if (ValidateDataSet(ds))
                {
                    proyects = CommonComboBoxDAOMapping.GetDataByNameMapping(ds);
                }
            }
            catch (SqlException ex)
            {
                Logger.Error(ex);
                throw new ServiceDataException(ServiceDataException.DAO_METHOD_EXCEPTION, "ProyectDAO", ex);
            }
            catch (DataException ex)
            {
                Logger.Error(ex);
                throw new ServiceDataException(ServiceDataException.DAO_METHOD_EXCEPTION,
                                               "ProyectDAO", ex);
            }
            catch (Exception ex)
            {
                Logger.Error(ex);
                throw new UnhandledException(MethodBase.GetCurrentMethod(), ex);
            }
            return proyects;
        }

        public List<TecnologyInfo> GetAssignedTecnologies(int projectId)
        {
            List<TecnologyInfo> tecnologyList = null;
            try
            {
                IList<IDbDataParameter> parameters = ProyectDAOHelper.GetIdParameter(projectId);
                DataSet ds = Retrieve("Proyect_R_AssignedTecnology", parameters);
                if (ValidateDataSet(ds))
                {
                    tecnologyList = TecnologyDAOMapping.GetTecnologies(ds);
                }
            }
            catch (SqlException ex)
            {
                Logger.Error(ex);
                throw new ServiceDataException(ServiceDataException.DAO_METHOD_EXCEPTION, "ProyecDAO", ex);
            }
            catch (DataException ex)
            {
                Logger.Error(ex);
                throw new ServiceDataException(ServiceDataException.DAO_METHOD_EXCEPTION,
                                               "ProyecDAO", ex);
            }
            catch (Exception ex)
            {
                Logger.Error(ex);
                throw new UnhandledException(MethodBase.GetCurrentMethod(), ex);
            }
            return tecnologyList;
        }

        public List<TecnologyInfo> GetUnAssignedTecnologies(int projectId)
        {
            List<TecnologyInfo> tecnologyList = null;
            try
            {
                IList<IDbDataParameter> parameters = ProyectDAOHelper.GetIdParameter(projectId);
                DataSet ds = Retrieve("Proyect_R_UnAssignedTecnology", parameters);
                if (ValidateDataSet(ds))
                {
                    tecnologyList = TecnologyDAOMapping.GetTecnologies(ds);
                }
            }
            catch (SqlException ex)
            {
                Logger.Error(ex);
                throw new ServiceDataException(ServiceDataException.DAO_METHOD_EXCEPTION, "ProyecDAO", ex);
            }
            catch (DataException ex)
            {
                Logger.Error(ex);
                throw new ServiceDataException(ServiceDataException.DAO_METHOD_EXCEPTION,
                                               "ProyectDAO", ex);
            }
            catch (Exception ex)
            {
                Logger.Error(ex);
                throw new UnhandledException(MethodBase.GetCurrentMethod(), ex);
            }
            return tecnologyList;
        }

        public List<AreaInfo> GetAssignedAreas(int projectId)
        {
            List<AreaInfo> areaList = null;
            try
            {
                IList<IDbDataParameter> parameters = ProyectDAOHelper.GetIdParameter(projectId);
                DataSet ds = Retrieve("Proyect_R_AssignedArea", parameters);
                if (ValidateDataSet(ds))
                {
                    areaList = AreaDAOMapper.GetAreaList(ds);
                }
            }
            catch (SqlException ex)
            {
                Logger.Error(ex);
                throw new ServiceDataException(ServiceDataException.DAO_METHOD_EXCEPTION, "ProyecDAO", ex);
            }
            catch (DataException ex)
            {
                Logger.Error(ex);
                throw new ServiceDataException(ServiceDataException.DAO_METHOD_EXCEPTION,
                                               "ProyecDAO", ex);
            }
            catch (Exception ex)
            {
                Logger.Error(ex);
                throw new UnhandledException(MethodBase.GetCurrentMethod(), ex);
            }
            return areaList;
        }

        public List<AreaInfo> GetUnAssignedAreas(int projectId)
        {
            List<AreaInfo> areaList = null;
            try
            {
                IList<IDbDataParameter> parameters = ProyectDAOHelper.GetIdParameter(projectId);
                DataSet ds = Retrieve("Proyect_R_UnAssignedArea", parameters);
                if (ValidateDataSet(ds))
                {
                    areaList = AreaDAOMapper.GetAreaList(ds);
                }
            }
            catch (SqlException ex)
            {
                Logger.Error(ex);
                throw new ServiceDataException(ServiceDataException.DAO_METHOD_EXCEPTION, "ProyecDAO", ex);
            }
            catch (DataException ex)
            {
                Logger.Error(ex);
                throw new ServiceDataException(ServiceDataException.DAO_METHOD_EXCEPTION,
                                               "ProyecDAO", ex);
            }
            catch (Exception ex)
            {
                Logger.Error(ex);
                throw new UnhandledException(MethodBase.GetCurrentMethod(), ex);
            }
            return areaList;
        }

        public void SaveProyectTecnologyDetail(int id, string tecnologyList)
        {
            try
            {
                IList<IDbDataParameter> parameters = ProyectDAOHelper.GetSaveDetailParams(id, tecnologyList);
                Create("Proyect_C_TecnologyDetail", parameters);
            }
            catch (SqlException ex)
            {
                Logger.Error(ex);
                throw new ServiceDataException(ServiceDataException.DAO_METHOD_EXCEPTION, "ProyectDAO", ex);
            }
            catch (DataException ex)
            {
                Logger.Error(ex);
                throw new ServiceDataException(ServiceDataException.DAO_METHOD_EXCEPTION,
                                               "ProyectDAO", ex);
            }
            catch (Exception ex)
            {
                Logger.Error(ex);
                throw new UnhandledException(MethodBase.GetCurrentMethod(), ex);
            }
        }

        public void SaveProyectAreaDetail(int id, string tecnologyList)
        {
            try
            {
                IList<IDbDataParameter> parameters = ProyectDAOHelper.GetSaveDetailParams(id, tecnologyList);
                Create("Proyect_C_AreaDetail", parameters);
            }
            catch (SqlException ex)
            {
                Logger.Error(ex);
                throw new ServiceDataException(ServiceDataException.DAO_METHOD_EXCEPTION, "ProyectDAO", ex);
            }
            catch (DataException ex)
            {
                Logger.Error(ex);
                throw new ServiceDataException(ServiceDataException.DAO_METHOD_EXCEPTION,
                                               "ProyectDAO", ex);
            }
            catch (Exception ex)
            {
                Logger.Error(ex);
                throw new UnhandledException(MethodBase.GetCurrentMethod(), ex);
            }
        }

        public bool CheckName(int id, string name)
        {
            bool isValid = false;
            try
            {
                IList<IDbDataParameter> parameters = ProyectDAOHelper.GetCheckNameParams(id, name);
                DataSet ds = Retrieve("Proyect_R_CheckName", parameters);
                isValid = !ValidateDataSet(ds);
            }
            catch (SqlException ex)
            {
                Logger.Error(ex);
                throw new ServiceDataException(ServiceDataException.DAO_METHOD_EXCEPTION, "ProyectDAO", ex);
            }
            catch (DataException ex)
            {
                Logger.Error(ex);
                throw new ServiceDataException(ServiceDataException.DAO_METHOD_EXCEPTION,
                                               "ProyectDAO", ex);
            }
            catch (Exception ex)
            {
                Logger.Error(ex);
                throw new UnhandledException(MethodBase.GetCurrentMethod(), ex);
            }
            return isValid;
        }

        public List<ProjectReportInfo> GetProjectStatus()
        {
            List<ProjectReportInfo> proyects = null;
            try
            {
                DataSet ds = Retrieve("Proyect_Grafic_Status");
                if (ValidateDataSet(ds))
                {
                    proyects = ProyectDAOMapping.GetProjectStatus(ds);
                }
            }
            catch (SqlException ex)
            {
                Logger.Error(ex);
                throw new ServiceDataException(ServiceDataException.DAO_METHOD_EXCEPTION, "ProyecDAO", ex);
            }
            catch (DataException ex)
            {
                Logger.Error(ex);
                throw new ServiceDataException(ServiceDataException.DAO_METHOD_EXCEPTION,
                                               "ProyecDAO", ex);
            }
            catch (Exception ex)
            {
                Logger.Error(ex);
                throw new UnhandledException(MethodBase.GetCurrentMethod(), ex);
            }
            return proyects;
        }
    }
}